{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 用 NumPy 来实现\n",
    "\n",
    "但是之前接触的只是单个节点的误差项。现在在更新权重时，我们需要考虑隐藏层 每个节点 的误差项 $\\delta_j$ ：\n",
    "\n",
    "$$\\Delta W_{ij} = \\eta \\delta_j x_i$$\n",
    "\n",
    "现在 $w_{ij}$ 是一个矩阵，所以右侧对应也应该有跟左侧同样的维度。如果用一个列向量数组和一个行向量数组相乘，它会把列向量的第一个元素与行向量的每个元素相乘，组成一个新的二维数组的第一行。列向量的每一个元素依次重复该过程，最后你会得到一个二维数组，形状是  \n",
    "*(len(column_vector), len(row_vector))*。\n",
    "\n",
    "```\n",
    "hidden_error*inputs[:,None]\n",
    "array([[ -8.24195994e-04,  -2.71771975e-04,   1.29713395e-03],\n",
    "       [ -2.87777394e-04,  -9.48922722e-05,   4.52909055e-04],\n",
    "       [  6.44605731e-04,   2.12553536e-04,  -1.01449168e-03],\n",
    "       [  0.00000000e+00,   0.00000000e+00,  -0.00000000e+00],\n",
    "       [  0.00000000e+00,   0.00000000e+00,  -0.00000000e+00],\n",
    "       [  0.00000000e+00,   0.00000000e+00,  -0.00000000e+00]])\n",
    "```\n",
    "\n",
    "这正好是计算权重更新的步长的方式。如果输入是一个一行的二维数组，可以用 hidden_error*inputs.T，但如果 inputs 是一维数组，就不行。\n",
    "\n",
    "#### 反向传播练习\n",
    "接下来用代码来实现一项数据，两层神经网络的反向传播。\n",
    "\n",
    "* 计算网络输出误差\n",
    "* 计算输出层误差项\n",
    "* 用反向传播计算隐藏层误差项\n",
    "* 计算反向传播误差的权重更新步长"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 1) (2, 3) (1, 2)\n",
      "Change in weights for hidden layer to output layer:\n",
      "[[0.0080988  0.00661094]]\n",
      "Change in weights for input layer to hidden layer:\n",
      "[[ 1.85301465e-04  3.70602930e-05 -7.41205859e-05]\n",
      " [-5.52590207e-04 -1.10518041e-04  2.21036083e-04]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "def sigmoid(x):\n",
    "    return 1.0 / (1 + np.exp(-x))\n",
    "\n",
    "x = np.array([0.5, 0.1, -0.2])\n",
    "target = 0.6\n",
    "learnrate = 0.5\n",
    "\n",
    "weights_input_hidden = np.array([[0.5, -0.6],\n",
    "                                 [0.1, -0.2],\n",
    "                                 [0.1, 0.7]])\n",
    "weights_hidden_output = np.array([0.1, -0.3])\n",
    "\n",
    "x = x.reshape(3,1)\n",
    "weights_input_hidden = weights_input_hidden.reshape(2,3)\n",
    "weights_hidden_output = weights_hidden_output.reshape(1,2)\n",
    "\n",
    "print(x.shape, weights_input_hidden.shape, weights_hidden_output.shape)\n",
    "\n",
    "## Forward pass\n",
    "hidden_layer_input = np.dot(weights_input_hidden, x)\n",
    "hidden_layer_output = sigmoid(hidden_layer_input)\n",
    "\n",
    "output_layer_in = np.dot(weights_hidden_output, hidden_layer_output)\n",
    "output = sigmoid(output_layer_in)\n",
    "\n",
    "## Backwards pass\n",
    "## Calculate output error\n",
    "error = target - output\n",
    "\n",
    "# Calculate error term for output layer\n",
    "output_error_term = error * output * (1 - output)\n",
    "\n",
    "# Calculate error term for hidden layer\n",
    "hidden_error_term = np.dot(weights_hidden_output.T, output_error_term) * \\\n",
    "                    hidden_layer_output * (1 - hidden_layer_output)\n",
    "\n",
    "# Calculate change in weights for hidden layer to output layer\n",
    "delta_w_h_o = learnrate * output_error_term * hidden_layer_output.T\n",
    "# Calculate change in weights for input layer to hidden layer\n",
    "delta_w_i_h = learnrate * hidden_error_term * x.T\n",
    "\n",
    "print('Change in weights for hidden layer to output layer:')\n",
    "print(delta_w_h_o)\n",
    "print('Change in weights for input layer to hidden layer:')\n",
    "print(delta_w_i_h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 实现梯度下降算法\n",
    "\n",
    "在该 Lab 中，实现构建梯度下降算法的基本函数，以便在小数据集中查找数据边界。首先绘制和可视化数据。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "# plotting and drawing lines\n",
    "\n",
    "def plot_points(X, y):\n",
    "    admitted = X[np.argwhere(y==1)]\n",
    "    rejected = X[np.argwhere(y==0)]\n",
    "    plt.scatter([s[0][0] for s in rejected], [s[0][1] for s in rejected], s = 25, color = 'blue', edgecolor = 'k')\n",
    "    plt.scatter([s[0][0] for s in admitted], [s[0][1] for s in admitted], s = 25, color = 'red', edgecolor = 'k')\n",
    "\n",
    "def display(m, b, color='g--'):\n",
    "    plt.xlim(-0.05,1.05)\n",
    "    plt.ylim(-0.05,1.05)\n",
    "    x = np.arange(-10, 10, 0.1)\n",
    "    plt.plot(x, m*x+b, color)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 读取与绘制数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3X9wXHd57/H3E8XCzW4KKXZncu0EkxJ+GNxEjsZLYFpaTCwr48Skl1CLhvbegZuh/OgwobexBxOZVTsEOhdKuEzBN83wo8WhTSeppVqVWkogQ69EZGwMyR24IdBGCVPMj5s7kq9jSTz3j9211+vV7tndc/b82M9rRhOtdLL6nrX0nLPP9/k+X3N3REQkWy6KewAiIhI+BXcRkQxScBcRySAFdxGRDFJwFxHJIAV3EZEMUnAXEckgBXcRkQxScBcRyaCL4/rB69at802bNsX140VEUuno0aM/dvf1zY6LLbhv2rSJubm5uH68iEgqmdm/BjlOaRkRkQxScBcRySAFdxGRDFJwFxHJIAV3EZEMUnAXEckgBXcRkQxqGtzN7D4z+5GZfXuV75uZ3WNmT5jZCTPbGv4wRZJtZWWFiYkJxsbGmJiYYGVlJe4hSY8LsojpM8B/Bz63yveHgavLHwXgz8v/FekJKysrDA3dwuzs0ywu7iCXG6VQOMjU1IP09fXFPTzpUU3v3N39q8BPGxyyG/icl8wALzCzy8MaoEjSTU5OMjv7NAsLM7h/iIWFGWZn55mcnIx7aNLDwsi5bwCeqno8X/7aBczsdjObM7O5kydPhvCjReJ37NgxFhd3AGvKX1nD4uIQx48fj3NY0uPCCO5W52te70B3P+jug+4+uH590743IqkwMDBALjcNLJW/skQuN8W1114b57Ckx4UR3OeBK6oebwSeCeF5RVJheHiYQmED+XwBs33k8wUKhY0MDw/HPTTpYWF0hTwMvNvM7qc0kfqsu/8whOcVSYW+vj6mph5kcnKS48ePc+21RYaHh1MzmbqyssLk5CTHjh1jYGAgVWOX1Zl73QzKuQPMDgG/AawD/h0YpZxcdPdPmZlRqqbZCZwC/rO7N+3lOzg46Gr5KxK9RsH7wkqfaQqFDar0STAzO+rug82Oa3rn7u4jTb7vwLtaGJuIdEmzMs3qSh9Yw8JCkdnZApOTk+zatSvu4UsHtEJVJMOalWmq0ie7FNxFMqxZ8FalT3YpuItkWLPgrUqf7Go6oRoVTaiKRO9czn2excUhcrkpCoWN502YViZcS5U+16paJuGCTqgquItknIJ3tii4i4hkUGilkCKSHlqQJBUK7iIZodbDUk3VMiIZodbDUk3BXSQjtCBJqim4i2SEFiRJNQV3kYzQgiSppglVkYxIe+thCZfq3EVEUiRonbvSMiIiGaS0jEiXdXuhkRY29SYFd5EuqrfQaNu2T/MHf/B2Tpw4EXrw1cKm3qXgLtJF9XY++spXruFf/uV9PPfcraEH3yzutKR3IsEo5y7SRfUWGq2s3MTp02+NZFVp1hY2Vd6JjIyMMjp6ipGRUYaGbmFlZSXuoSWOgrtIF9VbaAR/D1xXfhxu8M3awia1WAhOwV2ki2oXGq1dex19fT8G3lA+Itzgm7WFTVl7JxIl5dxFuqh2odGWLWPcc8+9fP3rrzlvp6Swgm/WFjaV3omMsrBQpBTgKxfDYtxDSxwtYhKJWTd3Skr7ZGSQbQOzTjsxich5LiyLnKZQ2JC6wNjr2wYquIvIeSYmJhgZGT1bFglL5PMFDh0qprYsshep/YCInEeTkb1FwV2kR7RaFrmyssLExARjY2NMTEyoljxlAlXLmNlO4ONAH3Cvu99d8/0rgc8CLygfs9fdj4Q8VpGeEcXEZ6ks8iCzs4WmlTlqW5B+TXPuZtYHfBe4AZgHHgVG3P3xqmMOAsfc/c/NbDNwxN03NXpe5dxF6oty4jPoZKTy88kVZs59G/CEuz/p7meA+4HdNcc48Ivlz58PPNPKYEXknChXYfb19bFr1y7279/Prl27Vr1YKD+ffkGC+wbgqarH8+WvVTsA3GZm88AR4D2hjE6kByUhsGatbUEvChLcrc7XanM5I8Bn3H0jcCPweTO74LnN7HYzmzOzuZMnT7Y+WpEekITAmrW2Bb0oSM79euCAuw+VH+8DcPcPVR3zGLDT3Z8qP34SeLW7/2i151XOXaS+MFZhhjEh2+uLhZIqtEVMZnYxpQnV7cDTlCZU3+Luj1UdMwl80d0/Y2avAL4EbPAGT67gLrK6TgJrkleipr39QRKEukLVzG4E/oxSmeN97v4nZlYE5tz9cLlC5n8AeUopmz9y9+lGz6ngLhKNditdog68Sb7oRCns1zVocA9U516uWT9S87W7qj5/HHhtq4MUkfA1mpCtF9wri5XuuONOnnlmmdOn/yP5fPh17VncFaqZONcLaIWqSMa0MiFbCT579tzFk0/u5vTp5wP/i4WFr4W+CUYSqoC6Lc7NRRTcRTKmlUqXSvA5fXoO+DAwQ6na+Z9CD7znLjqngQngAM973l+zZcuW0H5G0sR5QVNwF8mYygYdhw4VKRZzHDpUXDUNUC/4wBBwlFxuii1btoTSX2ZlZYWVlRXWr3+OUreSvcAplpaexz333JvZvjVxlrWq5a9IRNJQGTIxMcGePXexuHgX8C1gC/B+1q49zWtesxmAr3/9mY4mQKvzzgsLm4DHyj8r+20NothcJNQJVRFpTVoab+3YsYP+/nexuLgPuBnYx9q1P+Gv/upT9PX1cdttxY4nQM+fSL0buJqgk71pF+c2h0rLiEQgrom0Vtv0Tk9Ps7S0DjhBKed+gr6+jfT393PixIlQ8sXnp34GgH+kl9oaBO3nEzYFd5EIxDGRVnm3MDIyyujoKUZGRhkauqVhgK83zlOnSuMMK198/vMMA5cDWzDbq7YGEVJwF4lAo8AYxSYYKysrfPCDH+SRR+ZYWPgA7n8c6N1Co3EODw+zbdt/YO3alwO/ztq1L2fbtg0tB+Lzq3f2k8s9zTXXPJ8DBy5pONkrnVHOXSQCq22MsWPHjtBz8ZU79kce+T5nzrwVGAPuAx5sms8OtoFHHrge+Ie2xndh3nkskZPLmePusXxcd911LpJly8vLPj4+7mNjYz4+Pn72cT6/1eGMgzuc8Xx+wMfHx9v+OfWeEwYcHgz03PXGudrzdjrWuFTOsVgsnneOaUSp7UvTGKs7d5GIVCbSqu+aW20NEET9WvUb6O9/J4XCYNM0Sr1xtjvWJJZ/pqVyKWzKuct5tClytKJY1FLvOfv7/54773x7RwGsnQ21W53Q7YY4WwDEScFdzlpZWeGWoSFGR0Y4NTrK6MgItwwNxf7HmSVRbIJR7zl/7deuYnR0tKM701bHmtQg2os9bUATqlJlcnKSp2dnmVlYYA1QXFigMDub6a593RbFopaoFsq0+rxRpJzCUHoHMsrCQpHKqtjSO5BibGPqiiCJ+Sg+NKGaPMVi0feaeXn2zB18r5mPjY3FPTRJgaROwC4vL/v27Td5Pj/gZns9nx/w7dtvSu2kKgEnVJWWkbMGBgaYzuWqMqwwlctlevWghCep+6620kgtS9Q4TM6q5NznZ2cZWlxkKpdjY6HAg1NTmf9DSLukVKlo39XohbrNXhQU3JNJf5zp00vb1yXlIhYnBXeRHtHunqlp00sXsUaCBnfl3EVSrldK/ZJaaplUCu4iKRfnbj/Vol4A1ysXsbCozl2kA0nIAQdr/tWeoOfXjSX+PVuv3ibl3EXaVKkuenp2lh2Li0zncmyIqbooionwVnLc3cj7R7FlXRppmz2RiHWyojfsO/7Vmn914vzt8Rpvs9eN1amVevWJiQkeeOAB3Ddz6623hvLcWaScu0gDjfLIx44dY8fi4nm9GIcWF5vmgJPaYKtWKznubub9P/GJv+Chhx7nC1+4gttuKybytUsCBXdJhTi6VTYLwu2u6K1X9TEzk7yqj1YCdrdWp6piJjgFd0m8uLpVNgskw8PDbCgUKOTz7DOjkM+zsVBoGtCOHj3KwsIbOP+O+Aa+8Y1vRHo+rWolYHdrib8qZoJTzl0SL65ulc3yyH19fTw4NXV2IrMYcCKzdFE6DPwxlclH+DuWl98c+jnU5vZ37NjB9PR0oFx/q10ho8j711LFTHCBgruZ7QQ+DvQB97r73XWOeTNwAHDgm+7+lhDHKT2sUW477kDSTkArBUcDCsAQMAVcxMUXh3uvVVvtcskld9Hf/y6WltYFLlcMcn7dLAeNsuwzc5q1jaQU0L8HXAX0A98ENtccczVwDLis/PiXmz2vWv5KUOPj4741n/cz5TbEZ8AH8vnIW8lG1Sp2fHzcc7nSHqcw5vCg53LXhn4+F7bgfdDh5aG25D33Gm0tv0ZbI2+nu9qer72CgC1/gwT364Gpqsf7gH01x3wEeHuQH1j5UHCXoJaXl/2m7dt9IJ/3vWY+kM/7Tdu3+/LycuQbH0cRSLrVX7xYLLrZ3qr2/EWHP6pu1+9mezvq15/UHu5ZFjS4B3kfuAF4qurxPKX3k9VeCmBmXyvf6R9w93+ofSIzux24HeDKK68M8KNFWDW3DUS+KjKKPHJUOyfVujCttIXSvdm5XH+n+eqk7r4kBLpzv5VSnr3y+K3AJ2qOmQAepPQv/GJKF4AXNHpe3blLp87dNf4/h3GHUV+79ip/6KGH4h5aItS+Q8jlrvXLLrvSc7nw3jEEuXOP+t1VryHEO/d54IqqxxuBZ+ocM+PuS8D3zew7lPLwj7Z5zcmMJPQeyapjx46VSwrfDDwN7OD06V/gjjv2n61m6WUXvkMYO1stE9Y7hmYTnN3oOSOraBb9KVXUPEnpjrwyofrKmmN2Ap8tf76OUhrnhY2etxfu3Cu54q3lXPHWqlyxdG58fNzXrv0Vh/PvHNeu3dIw55uFO8kknUOjeYnz7+yXHR70/v7L/QMf+EAqX/ckIKwJ1dJzcSPwXUpVM+8vf60I3Fz+3ICPAo8D3wL2NHvOXgjucVV59Irl5WW/6qqXOfzXmknCO1edJKx3wb3+mmv8wIEDsQfJoOKoUGnXuUnd5xy2OVzu8Fu+Zs0rEzvmpAsa3AOtUHX3I+7+Unf/FXf/k/LX7nL3w+XP3d3vcPfN7r7F3e/v7P1ENrTbe0SC6evr46Mf/TBr105x/hL56VVbAFQviPqQOzMLC/z4m9/iwIFvJ7bHS600LcEfGBjgkkumgNcB/xf4XeAHLC1tYmbmqUSOOSvUfiBC7fYeWU0c/VWSbteuXbz2tS8K3NOk3gX3jThwTaKDZLU0LcEfHh7mJS9ZA/wMOAHcDcwAz7C4+JJEjjkrFNwj1G7vkXri6q+SdK32NKl3wX2IHHAtcQfJoBfvpOy8FERfXx+33HIjsBvOu6TuoL//a4kcc2YEyd1E8dELOXf38BbBKH8fjuoFUXea+dVc5Jfwm+XJvjOey8WzAKeVPHq3FkGFpV65JLzMr7lmW2LHnGSEOaEaxUevBPewFItF32vm1TOHe806Wl3YqyoX3AMHDngut97hpeWVmy/zyy670p977rmuj6nVlZ5pWoJfuRiV6uvv9P7+V/o111wfy+ucBUGDu9IyKRF2/r6XVVadXnfddZSWbXwYuBS4mzNnfonp6emuj6nVPHrlHPbvT35NfyV1dv/9RYrFPH/7t3dz9Ogj9Pf3xz20TFNwT4kw8/dScuzYMU6dGgLeCOwH3sipUztjybmnKY/ejjRdjLJCwT0lKv1ViocOkSsWKR46FNpGzL1ahZOkgNqtnYykd1gphdN9g4ODPjc3F8vPlnMqVThPz86yY3GR6VyODYVCaBeOJDu3NH7+vKXzcS2Nr7SqKLUGCLbxh/QeMzvq7oNNj1Nw720TExOMjoyc3eVoCSjk8xQPHWLXrl2Z742jgCppEzS4a5u9HtdoFe3w8PB5d/WjuRwHM3ZX342t4UTioJx7j2tUhVNvqf58ee9SEUk2Bfce16gKR71xRNJLaZket9ouR319fQwMDDCay1GsysdP5XIUM1KeJ5JlmlCVVVUqaeZnZxlaXGQql2NjxnLuvSDrk+K9RtUyEgpVk6TbhTshTVMobNBOSCmm4C4iTExMMDIyysLCDJVNsfP5AocOFVUhlFJBg7smVCUWUa6K7dUVt9Uqr8HHPvYxFhau4tyfenJ7v0u4NKEqXVe7KjbM+nltyHz+63vD4iLzGPPcwCn+Efh5ucVCMe5hSsQU3KXrquvn1wDFhQUK5fr5dlIF1ROGS0tLzMzMs7g4C6xhYaHI7Gyh4XNnbcKx9vUdw3klX+F/s4d8/nvqWdMjFNyl6xrVz7ca3GvfBUysWYOfuZx6aYh6zx3lu4i41Ht9f8ucudf/jPe+t5j6i5cEo5y7dN1qq2K3bNnScq68dhXtN86cYQNPAeNnn71Rp8csrsKt9/pO53K8973vVbvdHqLgLl1Xb1Xshm3buPeee1reI7b2LvUiYAs/p6/vrcCt5HLbWt4wO+2rcNX7X0BpGelQO/nqeqtiV1ZWKN52W8t5+OpVtBdR2ob5e8D7VhY40n+YS1/yCo4ceaDhhtlZW4XbaNWx9JAge/FF8aE9VLujstdmsVgMfa/NymbTW/N532vmW/N5v2n79rZ+Rrt7xFZveP0m8JeXNw8Puol49f+/18wHOjgHkW5Ae6hKZbIwaKqj1frwMPPV7e4RW71D1U9f/3p2m7WUYolyhyuRWAW5AkTxoTv36I2Pj/vWfD7QnWw7d+Ht3m3XE8YddCvnK5JW6M5dWpksbOcuvN277XrCuIPWRKLIOYGCu5ntNLPvmNkTZra3wXFvMjM3s6Z9DyR6rQTfdqpGwg6mlV2R9u/fz/DwMJOTky2VRVYuEKN/+ZfM/87vsHn3bt72nve0NRaR1Gt2aw/0USpAuAroB74JbK5z3KXAV4EZYLDZ8yotE71WUh3tpjQqE7ZjY2OhTdh2MlEb5iSvSBIRMC0TJLhfD0xVPd4H7Ktz3J8Bu4CHFdyTI2jwbTXnHWUVTie5c+XdJeuCBvcgde4bgKeqHs8DheoDzGwAuMLdJ8zsD1t++yCRCboBdCu10e0u2Q9aE99Je4IwWxuIpFmQnLvV+drZJvBmdhHwMeB9TZ/I7HYzmzOzuZMnTwYfpXRFdc670TL1diZfWynL7GSiNsxJXpE0CxLc54Erqh5vBJ6penwp8CrgYTP7AfBq4HC9SVV3P+jug+4+uH79+vZHLbFqZ/K1lQtCJxO1qpgRKQmSlnkUuNrMXgw8DewB3lL5prs/C6yrPDazh4E/dHdts9SmpLegbWfJfivpkk6Wz2vpfTBJ/x2TEARJzAM3At+lVDXz/vLXisDNdY59GE2oti0N1R7tLDjSRGdypOF3TFZHWNUyUX0ouNeXliDYagmkergkR1p+x6S+oMFdXSETJi3VHkGrcKqPT0u6JOspi7T8jklnFNwTJostaCtavSDEIYs7M9Xqxu9Y1i+QaaDeMgkTZrVHq10eJZs7M9WKuqKoskn5yMgoo6OnGBkZZWjoFv3+dZnu3DsU9h1KWOmLXrgDjUIvpCyiTpFNTk4yO/s0CwszBN2kXCIQJDEfxUcWJlSTXHXQbNIsyvYBaabJxs4Vi0U321vdCdrN9rbVClouhFr+Ri/Jb+Eb3YG2uolHLwmSslC6q7GBgQFyuWmoWifcaJNyiYaCewCr/TEneXPlRsvwk3xRiluzvvK6MDY3PDxMobCBfL6A2T7y+ULDTcolIkFu76P4SEtaplHqJclv4RvVlYe5g1LYY056qijJ/+ZJEkUraClBde7hqL7LXQMUFxYolO9yh4eHOVgoUJidZWhxkalcLjF9TBpNmiWx3DLqTpNh6YUJ1zCkoew184JcAaL4SMude7O73DTeoSRxtWg7d8RxTGjrzl3ihiZUw9GshWzQNrlJEsZ+pWGLutNkWNR1UtJCaZkmkpx66UTS3jZH3WkyLGlqoyC9zUp3+d03ODjoc3Pp6ApcyeseP36cazP4x5yEpeKVnPt8zUW00TuKiYkJRkdGzs6HLAGFfJ7ioUOJuWiJhM3Mjrr7BftlXHCcgnu6hB2Iaycyp3M5NsS0krXVi2g7F4Qwx6m+KRIHBfeE6iQwRBGI03732+13VUm6GEpvChrcVS3TRZ1Wd0RRqZHUmvekUrWMxA1VyyRPp9UdUayI1YbSrUnyqmSRagruXdRpYIgiEPdiaV8nvWF0MZS0UHDvok4DQxSBOIk171HqtDdML14MJZ00odpFYVR31JtABFS9EVAYE8hZL42VZFO1TEKFHRiirt7IWtnf2NgYp0ZH+VDV7/0+M3LFIvv3749xZCLBBA3uWqHaZWGvDG3U2KzTn5HF3ZyS2DRNJArKuadclNUbWez7rpy59AoF95SLsnoji2V/vTaBLL1LwT3lorwTzWrZXxo7eYq0ShOqEevGhGRU1Rtx9W4RkdWpWiYBktyHJOhFJ+tlf1mrBpLsU3BPgKQ25UryRaeb9DpIGgUN7oFy7ma208y+Y2ZPmNneOt+/w8weN7MTZvYlM3tRO4POmqROSKaxCqaTlgGrSePrIBJU0+BuZn3AJ4FhYDMwYmabaw47Bgy6+68CDwAfCXugaZTUCcmkXnRW02nLgNWk7XUQaUWQO/dtwBPu/qS7nwHuB3ZXH+DuX3b3U+WHM8DGcIeZTkmtqU7qRWc1Ud1hp+11EGlFkOC+AXiq6vF8+WureRtQ96/OzG43szkzmzt58mTwUaZUUmuqk3rRWU1Ud9hpex1EWhGk/YDV+VrdWVgzuw0YBF5X7/vufhA4CKUJ1YBjTLWkbUQN6djkubqKZWlpiekIWgak4XUQaVfTahkzux444O5D5cf7ANz9QzXHvQH4BPA6d/9Rsx/cC9Uy0p7aKpapSy7hJ/39vPDMGYZOnVK9vfS0MBuHPQpcbWYvBp4G9gBvqflhA8CngZ1BArtIIxc0Q1tcZBuw64476O/v1x22SABNg7u7L5vZu4EpoA+4z90fM7Mipb38DgN/CuSBvzEzgH9z95sjHLdkWL0c+85Tp+jv71dbXpGAArX8dfcjwJGar91V9fkbQh6X9DC15RXpnBqHSeKoikWkc9qsQxJHVSwinVNvGRGRFMn0Nnvq5Cci0ljqgnsW9/UUEQlb6iZU1clPRKS51AV3dfKLVxStd0UkfKkL7urkF5+oWu+KSPhSF9xVAx2Odu7AlRITSY/UTaiqBrpz7U5KN0qJJanrpYik8M4dzrXR3b9/P7t27VJgb1G7d+BKiYmkRyqDu3Sm3UlppcRE0iN1aRnpXLuNuZQSE0kPtR/oQZWc+/zsLEOLi9r8QiRFMt1+QDqjO3CR7NOdu4hIigS9c9eEqohIBiktE4C6UIpI2ii4N6EulKvTRU8kuRTcm6he8LMGKC4sUCgv+OnlVZm66Ikkm3LuTagLZX3qMyOSbAruTWjJfX1RXfTUUlgkHAruTWjJfX1RXPTUUlgkPAruTVQW/BQPHSJXLFI8dEh5ZaK56CnVIxIeTagGUOlC2csTqLWiWOWqlsIi4VFwl7aFfdFrt6GZiFxIaRlJDM1viIQn0J27me0EPg70Afe6+901338e8DngOuAnwG+7+w/CHapknRqaiYSnaeMwM+sDvgvcAMwDjwIj7v541THvBH7V3d9hZnuAW9z9txs9rxqHiYi0LszGYduAJ9z9SXc/A9wP7K45Zjfw2fLnDwDbzcxaGbCIiIQnSHDfADxV9Xi+/LW6x7j7MvAs8MIwBigiIq0LEtzr3YHX5nKCHIOZ3W5mc2Y2d/LkySDjExGRNgQJ7vPAFVWPNwLPrHaMmV0MPB/4ae0TuftBdx9098H169e3N2IREWkqSHB/FLjazF5sZv3AHuBwzTGHgd8rf/4m4J89ri2eRESkeSmkuy+b2buBKUqlkPe5+2NmVgTm3P0w8BfA583sCUp37HuiHLSIiDQWqM7d3Y8AR2q+dlfV56eBW8MdmoiItEsrVEVEMkjBXUQkgxTcRUQySF0hRSQS2kA9XgruIhI6baAeP6VlRCR02lUrfgruIhK6qDZQl+AU3EUkdFFsoC6tUXAXkdBpV634aUJVREKnXbXi13QnpqhoJyYRkdaFuROTiIikjIK7iEgGKbiLiGSQgruISAYpuIuIZJCCu4hIBim4i4hkUGx17mZ2EvjXNv7XdcCPQx5O0vXaOffa+YLOuReEdb4vcvf1zQ6KLbi3y8zmghTwZ0mvnXOvnS/onHtBt89XaRkRkQxScBcRyaA0BveDcQ8gBr12zr12vqBz7gVdPd/U5dxFRKS5NN65i4hIE4kN7ma208y+Y2ZPmNneOt9/npl9sfz9WTPb1P1RhifA+d5hZo+b2Qkz+5KZvSiOcYap2TlXHfcmM3MzS31lRZBzNrM3l/+tHzOzL3R7jGEK8Ht9pZl92cyOlX+3b4xjnGEys/vM7Edm9u1Vvm9mdk/5NTlhZlsjGYi7J+4D6AO+B1wF9APfBDbXHPNO4FPlz/cAX4x73BGf728Cl5Q///00n2/Qcy4fdynwVWAGGIx73F34d74aOAZcVn78y3GPO+LzPQj8fvnzzcAP4h53COf968BW4NurfP9GYBIw4NXAbBTjSOqd+zbgCXd/0t3PAPcDu2uO2Q18tvz5A8B2M7MujjFMTc/X3b/s7qfKD2eAjV0eY9iC/BsDjAEfAU53c3ARCXLO/wX4pLv/DMDdf9TlMYYpyPk68Ivlz58PPNPF8UXC3b8K/LTBIbuBz3nJDPACM7s87HEkNbhvAJ6qejxf/lrdY9x9GXgWeGFXRhe+IOdb7W2Urvxp1vSczWwAuMLdJ7o5sAgF+Xd+KfBSM/uamc2Y2c6ujS58Qc73AHCbmc0DR4D3dGdosWr1770tSd1Dtd4deG1ZT5Bj0iLwuZjZbcAg8LpIRxS9hudsZhcBHwP+U7cG1AVB/p0vppSa+Q1K784eMbNXufv/iXhsUQhyviPAZ9z9v5nZ9cDny+f78+iHF5uuxK6k3rnPA1dUPd7IhW/Xzh5jZhdTekvX6K1QkgU5X8zsDcD7gZvd/bkujS0qzc75UuBVwMNm9gNKucnDKZ9UDfp7/XfuvuTu3we+QyltZQ6oAAABPklEQVTYp1GQ830b8NcA7v4/gbWUerBkWaC/904lNbg/ClxtZi82s35KE6aHa445DPxe+fM3Af/s5dmKFGp6vuUUxacpBfY052ErGp6zuz/r7uvcfZO7b6I0z3Czu6d5V/Ugv9cPUZo8x8zWUUrTPNnVUYYnyPn+G7AdwMxeQSm4n+zqKLvvMPC75aqZVwPPuvsPQ/8pcc8sN5hxvhH4LqXZ9veXv1ak9AcOpV+CvwGeAL4OXBX3mCM+338C/h04Xv44HPeYoz7nmmMfJuXVMgH/nQ34KPA48C1gT9xjjvh8NwNfo1RJcxzYEfeYQzjnQ8APgSVKd+lvA94BvKPq3/iT5dfkW1H9XmuFqohIBiU1LSMiIh1QcBcRySAFdxGRDFJwFxHJIAV3EZEMUnAXEckgBXcRkQxScBcRyaD/D6uud9pR3e3qAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data = pd.read_csv('data.csv', header=None)\n",
    "X = np.array(data[[0,1]])\n",
    "y = np.array(data[2])\n",
    "plot_points(X,y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.78051  -0.063669]\n",
      " [ 0.28774   0.29139 ]\n",
      " [ 0.40714   0.17878 ]\n",
      " [ 0.2923    0.4217  ]\n",
      " [ 0.50922   0.35256 ]]\n",
      "[1 1 1 1 1]\n"
     ]
    }
   ],
   "source": [
    "print(X[0:5])\n",
    "print(y[0:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 待办： 实现基本函数\n",
    "\n",
    "现在轮到你练习了。 如之前所述，实现以下基本函数。\n",
    "\n",
    "- Sigmoid 激活函数\n",
    "\n",
    "$$\\sigma(x) = \\frac{1}{1+e^{-x}}$$\n",
    "\n",
    "- 输出（预测）公式\n",
    "\n",
    "$$\\hat{y} = \\sigma(w_1 x_1 + w_2 x_2 + b)$$\n",
    "\n",
    "- 误差函数\n",
    "\n",
    "$$Error(y, \\hat{y}) = - y \\log(\\hat{y}) - (1-y) \\log(1-\\hat{y})$$\n",
    "\n",
    "- 更新权重的函数\n",
    "\n",
    "$$ w_i \\longrightarrow w_i + \\alpha (y - \\hat{y}) x_i$$\n",
    "\n",
    "$$ b \\longrightarrow b + \\alpha (y - \\hat{y})$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Activation (sigmoid) function\n",
    "def sigmoid(x):\n",
    "    return 1.0 / (1 + np.exp(-x))\n",
    "\n",
    "# Output (prediction) formula\n",
    "def output_formula(features, weights, bias):\n",
    "    return sigmoid(np.dot(features, weights) + bias)\n",
    "\n",
    "# Error (log-loss) formula\n",
    "def error_formula(y, output):\n",
    "    return - (y * np.log(output) + (1-y) * np.log(1-output))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练函数\n",
    "\n",
    "该函数将帮助我们通过所有数据来迭代梯度下降算法，用于多个 epoch。 它还将绘制数据，以及在我们运行算法时绘制出一些边界线。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "np.random.seed(44)\n",
    "\n",
    "epochs = 500\n",
    "learnrate = 0.02\n",
    "\n",
    "def train(features, targets, epochs, learnrate, graph_lines=False):\n",
    "\n",
    "    errors = []\n",
    "    n_records, n_features = features.shape\n",
    "    last_loss = None\n",
    "\n",
    "    weights = np.random.normal(scale=1/n_features**.5, size=n_features)\n",
    "    bias = 0\n",
    "\n",
    "    start = time.time()\n",
    "    for e in range(epochs):\n",
    "        # 每项数据都更新一次 w 和 b，更新了 epochs * n_records 次\n",
    "        for x, y in zip(features, targets):\n",
    "            output = output_formula(x, weights, bias)\n",
    "            error_term = y - output\n",
    "            # Gradient descent step\n",
    "            weights += learnrate * error_term * x\n",
    "            bias += learnrate * error_term\n",
    "\n",
    "        # 所有数据只更新一次 w 和 b，更新了 epochs 次，效率很低\n",
    "#         del_w = np.zeros(weights.shape)\n",
    "#         del_b = 0\n",
    "#         for x, y in zip(features, targets):\n",
    "#             output = output_formula(x, weights, bias)\n",
    "#             error_term = y - output\n",
    "#             del_w += error_term * x\n",
    "#             del_b += error_term\n",
    "\n",
    "#         weights += learnrate * del_w / n_records\n",
    "#         bias += del_b / n_records\n",
    "\n",
    "        # 使用向量运算代替for循环，效果最好\n",
    "#         output = output_formula(features, weights, bias)\n",
    "#         loss = np.mean(error_formula(targets, output))\n",
    "#         error_term = y - output\n",
    "#         weights += learnrate * np.dot(error_term, features) # (100,) (100,2)\n",
    "#         bias += learnrate * error_term\n",
    "#         print(loss)\n",
    "\n",
    "        # Printing out the log-loss error on the training set\n",
    "        out = output_formula(features, weights, bias)\n",
    "        loss = np.mean(error_formula(targets, out))\n",
    "        errors.append(loss)\n",
    "        if e % (epochs / 10) == 0:\n",
    "            print(\"\\n========== Epoch\", e,\"==========\")\n",
    "            if last_loss and last_loss < loss:\n",
    "                print(\"Train loss: \", loss, \"  WARNING - Loss Increasing\")\n",
    "            else:\n",
    "                print(\"Train loss: \", loss)\n",
    "            last_loss = loss\n",
    "            predictions = out > 0.5\n",
    "            accuracy = np.mean(predictions == targets)\n",
    "            print(\"Accuracy: \", accuracy)\n",
    "        if graph_lines and e % (epochs / 100) == 0:\n",
    "            display(-weights[0]/weights[1], -bias/weights[1])\n",
    "\n",
    "    # Plotting the solution boundary\n",
    "    plt.title(\"Solution boundary\")\n",
    "    display(-weights[0]/weights[1], -bias/weights[1], 'black')\n",
    "\n",
    "    # Plotting the data\n",
    "    plot_points(features, targets)\n",
    "    plt.show()\n",
    "\n",
    "    # Plotting the error\n",
    "    plt.title(\"Error Plot\")\n",
    "    plt.xlabel('Number of epochs')\n",
    "    plt.ylabel('Error')\n",
    "    plt.plot(errors)\n",
    "    plt.show()\n",
    "    total = (time.time() - start) * 1000\n",
    "    print(\"cost {} ms\".format(total))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 是时候来训练算法啦！\n",
    "\n",
    "当我们运行该函数时，我们将获得以下内容：\n",
    "\n",
    "- 目前的训练损失与准确性的 10 次更新  \n",
    "- 获取梯度下降过程中的数据图和一些边界线。最后一个是黑色的。请注意，随着遍历更多的 epoch，线会越来越接近最佳状态。  \n",
    "- 绘制误差函数的图。请留意，随着遍历更多的 epoch，误差会降低。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "========== Epoch 0 ==========\n",
      "Train loss:  0.6969355738794727\n",
      "Accuracy:  0.52\n",
      "\n",
      "========== Epoch 50 ==========\n",
      "Train loss:  0.3247888290187156\n",
      "Accuracy:  0.92\n",
      "\n",
      "========== Epoch 100 ==========\n",
      "Train loss:  0.2449389914332551\n",
      "Accuracy:  0.94\n",
      "\n",
      "========== Epoch 150 ==========\n",
      "Train loss:  0.2114837717532527\n",
      "Accuracy:  0.94\n",
      "\n",
      "========== Epoch 200 ==========\n",
      "Train loss:  0.19299944018934095\n",
      "Accuracy:  0.93\n",
      "\n",
      "========== Epoch 250 ==========\n",
      "Train loss:  0.1812468744592927\n",
      "Accuracy:  0.93\n",
      "\n",
      "========== Epoch 300 ==========\n",
      "Train loss:  0.1731130780816076\n",
      "Accuracy:  0.93\n",
      "\n",
      "========== Epoch 350 ==========\n",
      "Train loss:  0.16715486048755707\n",
      "Accuracy:  0.93\n",
      "\n",
      "========== Epoch 400 ==========\n",
      "Train loss:  0.16260898970200194\n",
      "Accuracy:  0.91\n",
      "\n",
      "========== Epoch 450 ==========\n",
      "Train loss:  0.15903284096499448\n",
      "Accuracy:  0.91\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cost 1359.431505203247 ms\n"
     ]
    }
   ],
   "source": [
    "train(X, y, epochs, learnrate, True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
